{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "from scipy import ndarray\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors=['lightgray','blue','orchid','red','green','purple','navy','violet','darkorange','gray','gray','gray','lawngreen','darkmagenta','black','thistle','indianred']\n",
    "current_palette = sns.color_palette(colors)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "%config InlineBackend.figure_format = 'svg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_majority.csv'\n",
    "datapd_0=pd.read_csv(filename, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_minority.csv'\n",
    "datapd_1=pd.read_csv(filename, index_col=0 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_val_1.csv'\n",
    "dataval_1=pd.read_csv(filename, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename='preprocessed_val_2.csv'\n",
    "dataval_2=pd.read_csv(filename, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority class dataframe shape: (16383, 99)\n",
      "Minority class dataframe shape: (625, 99)\n"
     ]
    }
   ],
   "source": [
    "print('Majority class dataframe shape:', datapd_0.shape)\n",
    "print('Minority class dataframe shape:', datapd_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_feat=datapd_0.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Imbalance Ratio: 26.2128\n"
     ]
    }
   ],
   "source": [
    "print('Imbalance Ratio:', datapd_0.shape[0]/datapd_1.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_0_trn=np.asarray(datapd_0)\n",
    "features_1_trn=np.asarray(datapd_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_val1=np.asarray(dataval_1)\n",
    "features_val2=np.asarray(dataval_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def knn(X_train,y_train,X_test):\n",
    "    from sklearn import metrics\n",
    "    from sklearn.neighbors import KNeighborsClassifier\n",
    "    from sklearn.metrics import confusion_matrix\n",
    "    from sklearn.metrics import f1_score\n",
    "    from sklearn.metrics import average_precision_score\n",
    "    from sklearn.metrics import balanced_accuracy_score    \n",
    "    knn = KNeighborsClassifier(n_neighbors=10)\n",
    "    knn.fit(X_train, y_train)\n",
    "    y_pred= knn.predict(X_test)\n",
    "    return(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Neb_grps(data,near_neb):\n",
    "    nbrs = NearestNeighbors(n_neighbors=near_neb, algorithm='ball_tree').fit(data)\n",
    "    distances, indices = nbrs.kneighbors(data)\n",
    "    neb_class=[]\n",
    "    for i in (indices):\n",
    "        neb_class.append(i)\n",
    "    return(np.asarray(neb_class)) \n",
    "\n",
    "def LoRAS(data,num_samples,shadow,sigma,num_RACOS,num_afcomb):\n",
    "    np.random.seed(42)\n",
    "    data_shadow=([])\n",
    "    for i in range (num_samples):\n",
    "        c=0\n",
    "        while c<shadow:\n",
    "            data_shadow.append(data[i]+np.random.normal(0,sigma))\n",
    "            c=c+1\n",
    "    data_shadow==np.asarray(data_shadow)\n",
    "    data_shadow_lc=([])\n",
    "    for i in range(num_RACOS):\n",
    "        idx = np.random.randint(shadow*num_samples, size=num_afcomb)\n",
    "        w=np.random.randint(100, size=len(idx))\n",
    "        aff_w=np.asarray(w/sum(w))\n",
    "        data_tsl=np.array(data_shadow)[idx,:]\n",
    "        data_tsl_=np.dot(aff_w, data_tsl)\n",
    "        data_shadow_lc.append(data_tsl_)\n",
    "    return(np.asarray(data_shadow_lc))   \n",
    "\n",
    "def LoRAS_gen(num_samples,shadow,sigma,num_RACOS,num_afcomb):\n",
    "    RACOS_set=[]\n",
    "    for i in range (len(nb_list)):\n",
    "        RACOS_i= LoRAS(features_1_trn[nb_list[i]],num_samples,shadow,sigma,num_RACOS,num_afcomb)\n",
    "        RACOS_set.append(RACOS_i)\n",
    "    LoRAS_set=np.asarray(RACOS_set)\n",
    "    LoRAS_1=np.reshape(LoRAS_set,(len(features_1_trn)*num_RACOS,n_feat))\n",
    "    return(np.concatenate((LoRAS_1,features_1_trn)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Without preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "features=np.concatenate((features_1_trn,features_0_trn))\n",
    "labels=np.concatenate((np.zeros(len(features_1_trn))+1, np.zeros(len(features_0_trn))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 17.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "y_pred_norm1=knn(features,labels,features_val1)\n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(y_pred_norm1==1)]\n",
    "\n",
    "with open('predict_val1_100_norm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 29.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "y_pred_norm2=knn(features,labels,features_val2)\n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(y_pred_norm2==1)]\n",
    "\n",
    "with open('predict_val2_100_norm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py:92: NumbaPerformanceWarning: \u001b[1m\u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\utils.py\", line 409:\u001b[0m\n",
      "\u001b[1m@numba.njit(parallel=True)\n",
      "\u001b[1mdef build_candidates(current_graph, n_vertices, n_neighbors, max_candidates, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\u001b[0m\n",
      "  current_graph, n_vertices, n_neighbors, max_candidates, rng_state\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py\", line 47:\u001b[0m\n",
      "\u001b[1m    @numba.njit(parallel=True)\n",
      "\u001b[1m    def nn_descent(\n",
      "\u001b[0m    \u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n"
     ]
    }
   ],
   "source": [
    "import umap.umap_ as umap\n",
    "data_embedded = umap.UMAP(n_neighbors=5, min_dist=0.01, n_components=2, metric='euclidean', random_state=11).fit_transform(features)\n",
    "data_embedded[:,0]=(data_embedded[:,0]- np.mean(data_embedded[:,0]))/np.std(data_embedded[:,0])\n",
    "data_embedded[:,1]=(data_embedded[:,1]- np.mean(data_embedded[:,1]))/np.std(data_embedded[:,1])\n",
    "data_embedded.shape\n",
    "result = pd.DataFrame(data = data_embedded , \n",
    "        columns = ['UMAP_0', 'UMAP_1'])\n",
    "result['Cluster'] = labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('white')\n",
    "sns.lmplot( x=\"UMAP_0\", y=\"UMAP_1\",\n",
    "  data=result, \n",
    "  fit_reg=False, \n",
    "  legend=False,\n",
    "  hue='Cluster', # color by cluster\n",
    "  scatter_kws={\"s\": 1},  palette=current_palette, height=5, aspect=1) # specify the point size\n",
    "plt.tight_layout()\n",
    "plt.savefig('cluster11_100_no_oversampling.png',dpi=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LoRAS overampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 47.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "num_samples=30\n",
    "shadow=100\n",
    "sigma=.005\n",
    "num_RACOS=(len(features_0_trn)-len(features_1_trn))//len(features_1_trn)\n",
    "num_afcomb=50\n",
    "nb_list=Neb_grps(features_1_trn, num_samples)\n",
    "    \n",
    "LoRAS_1=LoRAS_gen(num_samples,shadow,sigma,num_RACOS,num_afcomb)\n",
    "LoRAS_train=np.concatenate((LoRAS_1,features_0_trn))\n",
    "LoRAS_labels=np.concatenate((np.zeros(len(LoRAS_1))+1, np.zeros(len(features_0_trn))))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 21.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(LoRAS_train,LoRAS_labels,features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_100_LoRAS.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 45.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "num_samples=30\n",
    "shadow=100\n",
    "sigma=.005\n",
    "num_RACOS=(len(features_0_trn)-len(features_1_trn))//len(features_1_trn)\n",
    "num_afcomb=50\n",
    "nb_list=Neb_grps(features_1_trn, num_samples)\n",
    "    \n",
    "LoRAS_1=LoRAS_gen(num_samples,shadow,sigma,num_RACOS,num_afcomb)\n",
    "LoRAS_train=np.concatenate((LoRAS_1,features_0_trn))\n",
    "LoRAS_labels=np.concatenate((np.zeros(len(LoRAS_1))+1, np.zeros(len(features_0_trn))))\n",
    "    \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 35.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(LoRAS_train,LoRAS_labels,features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_100_LORAS.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "feats=np.concatenate((LoRAS_train[np.where(LoRAS_labels==1)][np.random.choice(len(LoRAS_train[np.where(LoRAS_labels==1)]), 2000, replace=False)], LoRAS_train[np.where(LoRAS_labels==0)]))\n",
    "labs=np.concatenate((np.zeros(2000)+1,np.zeros(len(LoRAS_train[np.where(LoRAS_labels==0)]))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\rp_tree.py\", line 135:\u001b[0m\n",
      "\u001b[1m@numba.njit(fastmath=True, nogil=True, parallel=True)\n",
      "\u001b[1mdef euclidean_random_projection_split(data, indices, rng_state):\n",
      "\u001b[0m\u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py\", line 47:\u001b[0m\n",
      "\u001b[1m    @numba.njit(parallel=True)\n",
      "\u001b[1m    def nn_descent(\n",
      "\u001b[0m    \u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\spectral.py:229: UserWarning: Embedding a total of 10 separate connected components using meta-embedding (experimental)\n",
      "  n_components\n"
     ]
    }
   ],
   "source": [
    "data_embedded = umap.UMAP(n_neighbors=5, min_dist=0.01, n_components=2, metric='euclidean', random_state=11).fit_transform(feats)\n",
    "data_embedded[:,0]=(data_embedded[:,0]- np.mean(data_embedded[:,0]))/np.std(data_embedded[:,0])\n",
    "data_embedded[:,1]=(data_embedded[:,1]- np.mean(data_embedded[:,1]))/np.std(data_embedded[:,1])\n",
    "data_embedded.shape\n",
    "result = pd.DataFrame(data = data_embedded , \n",
    "        columns = ['UMAP_0', 'UMAP_1'])\n",
    "result['Cluster'] = labs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('white')\n",
    "sns.lmplot( x=\"UMAP_0\", y=\"UMAP_1\",\n",
    "  data=result, \n",
    "  fit_reg=False, \n",
    "  legend=False,\n",
    "  hue='Cluster', # color by cluster\n",
    "  scatter_kws={\"s\": 1},  palette=current_palette, height=5, aspect=1) # specify the point size\n",
    "plt.tight_layout()\n",
    "plt.savefig('cluster11_100_LoRAS.png',dpi=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.neighbors.base module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.ensemble.bagging module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.ensemble. Anything that cannot be imported from sklearn.ensemble is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.ensemble.base module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.ensemble. Anything that cannot be imported from sklearn.ensemble is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.ensemble.forest module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.ensemble. Anything that cannot be imported from sklearn.ensemble is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "Using TensorFlow backend.\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.utils.testing module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.utils. Anything that cannot be imported from sklearn.utils is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:143: FutureWarning: The sklearn.metrics.classification module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.metrics. Anything that cannot be imported from sklearn.metrics is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from imblearn.over_sampling import SMOTE \n",
    "sm = SMOTE(random_state=62, k_neighbors=10,  kind='regular',ratio=1)\n",
    "SMOTE_feat, SMOTE_labels = sm.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 24.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat, SMOTE_labels, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_100_SMOTE.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 50.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat, SMOTE_labels, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_100_SMOTE.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "feats=np.concatenate((SMOTE_feat[np.where(SMOTE_labels==1)][np.random.choice(len(SMOTE_feat[np.where(SMOTE_labels==1)]), 2000, replace=False)], SMOTE_feat[np.where(SMOTE_labels==0)]))\n",
    "labs=np.concatenate((np.zeros(2000)+1,np.zeros(len(SMOTE_feat[np.where(SMOTE_labels==0)]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\numba\\compiler.py:602: NumbaPerformanceWarning: \u001b[1m\n",
      "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n",
      "\n",
      "To find out why, try turning on parallel diagnostics, see http://numba.pydata.org/numba-doc/latest/user/parallel.html#diagnostics for help.\n",
      "\u001b[1m\n",
      "File \"..\\..\\..\\..\\..\\Anaconda3\\lib\\site-packages\\umap\\nndescent.py\", line 47:\u001b[0m\n",
      "\u001b[1m    @numba.njit(parallel=True)\n",
      "\u001b[1m    def nn_descent(\n",
      "\u001b[0m    \u001b[1m^\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "  self.func_ir.loc))\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\umap\\spectral.py:229: UserWarning: Embedding a total of 7 separate connected components using meta-embedding (experimental)\n",
      "  n_components\n"
     ]
    }
   ],
   "source": [
    "data_embedded = umap.UMAP(n_neighbors=5, min_dist=0.01, n_components=2, metric='euclidean', random_state=11).fit_transform(feats)\n",
    "data_embedded[:,0]=(data_embedded[:,0]- np.mean(data_embedded[:,0]))/np.std(data_embedded[:,0])\n",
    "data_embedded[:,1]=(data_embedded[:,1]- np.mean(data_embedded[:,1]))/np.std(data_embedded[:,1])\n",
    "data_embedded.shape\n",
    "result = pd.DataFrame(data = data_embedded , \n",
    "        columns = ['UMAP_0', 'UMAP_1'])\n",
    "result['Cluster'] = labs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAFgCAYAAACFYaNMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXxU5b0/8M+ZMzOZLbNknSQkgCiL8lPEW60tVtpaK1ipBRG1oshSFSwCQt1atKjYiqh1SbVARK0bVNubVqkvtVev0VtvXXnllkW2AFkny2yZJDNz5vz+eDwnM8kkmZnMzJnJfN+vF6+TTGZ5AuSbZ77P9/k+nCiKIgghhKSdSukBEEJIrqIATAghCqEATAghCqEATAghCqEATAghCsnoALxs2TKlh0AIISmT0QG4q6tL6SEQQkjKZHQAJoSQsYwCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMCGEKIQCMMlJgiCgq6sLgiAoPRSSwygAk5y0b98+NDY2Yt++fRSEiWIoAJOcc+zYsYjP3W63MgMhOU+t9AAISQe/34+DBw8CAA4c0GLjxolwOFRob8/DwoXAM88AVqvCgyQ5h2bAZMyS8rxer1cOvgCwfn0l/v1vAxwOHUSRw65dKtTWKjhQkrNoBkzGJEEQcPjwYRw9GkJ1dSmqqgphtYYwZ44LjY3ar+8lguNUuPJKYN48RYdLchQFYDKmCIIAt9uN1tZWBINBbN9ejtpaK3hehFYrQq8XsXFjI+6/vwKPP+7Hz36mV3rIJIdRACZZw+v1orGxERaLBcXFxeB5ftB93G43mpubEQqFAADLl7fB7+dQVdULqzWE2bPdMJtDWLiwB1OmTEn3t0BIBArAJGs0NjYiEAigvb0dGo0GKpUKZrM5IhBrNBo5+LrdKnz6qQm3394MAHjvPbN8v4qKivQOnpAoKACTjNTT04PGxkYIggCVSgWLxYL8/Hx0dnbCZDJBFEU0NTV9vcBWhBtv5PHMMwJUqjZUV5dj+fI2fPqpCQ89ZJefU/p43jwnTCaTUt8aITIKwCQtBEFAZ2cnent7UVpaCq1WO+z9m5qa0NvbK3/e1taG0tJSVFRUwGw2w+l0QhRFuFwurFhRjKNHNVixQsT/+3821NZa4fcDt9/eAgCYPbu/znf2bDfNfknGoDI0khZOpxOtra1wuVw4ePAgmpqa0NHRAUEQIrYFSx9HC9Ctra1obW3FiRMnEAgE5Pvce+9JTJzYh3vvPYEzzhCg0YiYPLkXZnMI8+Y5YTaH5I+tVsBms6X72yckKpoBk7QYuN23s7MTAODz+SCKIjweD0KhEEKhENra2qIusAFAMBiE1+uF1+uVb5s5sxe1tYeg1Wrxve/pYDI1Rcx6JQUFBSgtLU3id0XI6FAAJmnR19cX9XaXyyV/7HQ6AQCiKCIYDMb1/DzPIxAIQBS7MG+eCxzHQRTZ11QqFaZMmTJkUCdEKZSCIGkx1MzTYDDIH/f09KCnp2fI51Cphv7vKs2wA4EAOI4DAPlqMpko+JKMRDNgoqje3l6oVCq5dGw4oVAIJpMJPp8PoVAIHMchPz8fHMdBq9XC4XDA5/PJ9y8uLkYwGERxcXEqvwVCEkYBmKRFa2tr1NtjCbwStVqNyspKOJ1ONDc3Iz8/H0ajEXl5eTh58mTEfU0mE4qKimjmSzIaBWCSUn6/H62traPuuatWq5Gfn4+mpiYUFRWhrKwMPp8PLS0tEKVkb5jKykoKviTjUQ6YpIwgCDh48CBcLhe8Xq+ck40Xz/MoLCxEV1cXXC6XvAHD5XJFLVcbuDtuLKurA6ZOZVeSfSgAk5QZ2OhcFEV5R1s8BEEAx3EoLCwEz/Po6emBx+MBEFldoVarMXnyZFRVVY1+8Fli+XLgwAF2JdmHAjBJGbPZPOg2g8GAcePGxf1cgiAgFAoNmcrQ6XSYOnXqiDvsxprt24EpU9iVZB/KAZOUGZgG4DgOBoMBPM/DYDBEVCyMxOfzwWg0Dvk6ubq9eNYsYP9+pUdBEkUBmKSUWq2WN1WIooj29nbodLqIPg+x6O3tRXd396Db8/PzMW7cuJzJ+ZKxhVIQJKXGjx8vB0etVgudToe2traYy8/UajZHGCr1QMGXZDMKwCSl9Hq9nDrQ6XQoKCiIqxnOcFuSJ0yYQMGXZDUKwCTlDAaDnP8FENFIJ1FarTbnFtzI2EMBmKSczWZDeXk5bDYb3G43AoHAqJ/T7/fD4XAkYXSEKCdtATgQCGDDhg245pprcMUVV+Ddd99N10sThfE8D5vNBp7nYTabUV5ejsrKylE9p16vz+keD7t3A1Yru5LslbYAXFtbC6vVipdeegnbtm3Dfffdl66XJhlECsYWiwWTJ09O6DmKioowYcKEnE5BrFgBuFzsSrJX2gLwJZdcgltvvVX+nBZPiFarRWFhYVyPKSsrg91uz/n/P9u2ARYLu5LslbY6YGkl3Ov1YvXq1VizZk26XppkMJ1OF9P9bDYbBd4wCxeyPyS7pXUjRnNzM1atWoVrrrkGl112WTpfmmQoabuy0WiEy+VCV1cX/H4/AHbEvF6vh91uz+l0Axm70haA29vbsXTpUmzcuBHnn39+ul6WZDgpJwywBuq5vLBGck/acsBPP/003G43qqursXjxYixevDju7aiEEDKWcGK0btYZYv78+Xj99deVHgYhhKQEbcQghBCFUAAmhBCFUAAmhBCFUAAmhBCFUAAmhBCFUAAmhBCFUAAmhBCFUAAmhBCFUAAmhBCFUAAmJExdHTB1KrsSkmoUgAkJc/31wIED7EpIqlEAJiTMGWdEXglJpbT2AyYk0z32mACbLYh77lEDoObvJLUoABPytb17gYsvDqG1VQOe96CmxqL0kMgYRykIQr52441Aa6saAIdnn81XejgkB1AAJuRr5eXSRyJmz1ZwICRnUAqCEACvvOLHW2/xmDULuPxyHsuWKT0ikgtoBkxyXl0dcPXVanR3q/CvfwG33QZYrcl57p07AYOBXQkZiAIwyXlLlwIABwAQBC6pz71yJdDTw65K2rMHKCtjV5I5KACTnHfllQDHASqViD/8IblHJFZXA3o9uypp6VKgpUX6ZUMyBeWASc5bvx6YPJnDvHlc0lIPkiVL2B+l1dSw4FtTo/RISDgKwCTnWa3AddcpPYrUmjMHaG5WehRkIEpBEEKIQigAE0KIQigAE0KIQigAE0KIQigAE0KIQigA5xgqyCckc1AZWo5ZsIDtzFqwAPD5lB4NIbmNZsA5pqcn8koIUQ4F4Byzdm3kNZNQeoTkGk4UxeRufk+i+fPn4/XXX1d6GCRNyspYvwK7nXZtkdxAM2CSMWpqWPClfgUkV1AAJhlD6ldw/vnA888DTqfSIyIktagKgmSMhgbWDP3zz4GODnbbWG+SQ3IbzYBTrK4OmDqVXcnwZs4EXnsNOHKEpSLmzVN6RISkFgXgFFu+HDhwgF3J8Do7AUAEEMJ3vyskvTcvIZmGAnCKbd8OTJnCrmR455wDsADM4Zlnkns0ECGZiAJwis2aBezfz65keJ98Avz61yI4TsS992ZsdSQhSUMBOMdk+im9GzfyCIVU2LiRV3oohKQcBeAcc/PNbBvyzTcrPRJCCAXgHHPttZFXQohyqA44x2zZAlxwAZV4EZIJKADnmFw4ATiTNTQ0wOPxID8/H+PHj1d6OERhaU9BfPnll1i8eHG6X5aQjODxeCKuJLeldQa8bds21NbWQq/Xp/NlCckY+fn58gyYkLTOgKuqqvDEE0+k8yUJySjjx4/H9OnTKf0Qo7G+lT+tAfiHP/wh1GpKOxNCYjPWt/JTGRohJGON9a38FICz2FNPCdBqQ3jqKUHpoRCSEmN9Kz8F4Cy2di2HQIDD2rXUuIaQbJT2ADxu3Djs2rUr3S87Jj36qAiNRsSjj1LjGkKyEc2As9iqVTz8fhVWraLGNSS3VVcDWi27ZhMKwAMk+g9JR6oTopw1a4BAgF2zCQXgARL9h1y6lB2pvnRpasZFCBnaY48BGg27ZhMKwAMk+g9JR6qTsUgQBHR0dKCjowOCkLnVNitXAn4/u2YTThTFjF3BmT9/Pl5//XWlh0FIzunp6cHRo0cRCoUAABzHoby8HDabTeGRjS20LY0QEqG1tRUOhyPiNlEUodFoFBrR2EUpCEIIAJZuaGpqGhR8JceOHUNHR0eaRzW2UQAmhEAQBDQ2NqKzs3PY+zU3N2d0LjjbUADOULt3s+bpu3crPRKSCzo7O+F2u2O6b6z3IyOjAJyhVqwAXC52JSTVenp6Yr6v2WxO4UhyCwXgJLrrLoDj2HW0tm0DLBZ2JSTVtFqt0kPISVSGlkRcWE+czP1bJWSw/fv3IxgMxnTfiooKKkdLEpoBJ9Gdd0ZeCckGgiDEHHwBQKfTpXA0uYUCcBJt3sxmvps3Kz0SQkYmCAK6urrQ3t4e1+NGqpQgsaONGITkKLfbjZaWlrgeo9VqUVxcnKIR5R6aAROSxbxeLw4ePAiv1xv3Y81mM0pKSmKu6+V5HhMmTKAFuySiAExIFmtsbITf70djY2Pcj+V5HoFAIOb7azQa8DyPrq4u2oyRJBSACcliFosl4hoPv98fV/5XEAQ5bUGbMZKDcsCEZLHi4mLk5eUltDni5MmTcd1fEAQYjUbY7XbajJEkNAMmJIvxPA+bzQaej+9YKkEQ4PP54n49h8MBs9kc9+ulQkdHB+rr67O6QRAF4ARt2iRApQph0ybKhZHs4vf7cfTo0Zjv/9lnOvz4x5Pxf/9nQVdXF44cOYLjx4/D7/encJTD8/v9aG5uBgD5mo0oACfonns4iCKHe+6hI+FJdmltbUVvb2/M9//Vrypx5IgG69cXAQD6+vrgdrvR0NCg2GLcUC0zsw0F4ASpVJHXVKirA6ZOZVdCkiWeMjK3W4WJE3vBcSJ++MOuiK/19fUN2pQhCAIcDgdOnDiRkhmylHbo6uofS35+ftJfJ11oES5BO3aosHIlUF2duhnw0qXAV1+x68GDKXsZMoK9e4HVq4HHHwfOPFPp0SROqmKIZ9vxe++Z8fnnRixY4MSSJYN3wLW2tsLpdEKn08Hr9UbMiF0uFwBg+vTpox/818LTDRzH4YwzzkjacyuBZsAJWrIE8PnYNVUWLmTX9naaBStp5Urg/fez78DHgdxuN5qbmyNmjyOZPduN229vwYYN7aioMMJkMg26T19fH1wuV9rTEYmU3mUaCsAZas8e4Kmn2MddXcDy5cqOJ5fNmQOo1eyajaSeD0ajMe5GOlYrsGhRHwwGPzweD/R6PWw2GyoqKsBxyq5/lJWVweFwoL6+PmtzwpSCyFDXX88asgMAzwPbtys7nly2ahVQWQnMm6f0SBIjbZ6w2+0oKSnBsWPHYn5sKBSC1WqFVquF2+1GX18fPB4PdDod8vPz4Xa75cM6KyoqoNfr4XQ6AQBWqzXp5WoD0xmtra3ytaCgICPK4+JBAThDnXMO8Pe/AxoN8J//CcyapfSIxi6Xy4UTJ05Aq9XCYrGgqKgo4gfZagWuu07BAY6StGnCaDTi+PHjcT22qKgIVqtVXugSBAGiKEbkkfV6Pbq7uxEIBGAymVBYWJi8wY9Ao9HI26ndbnfW9SmmFESGmjat/+ME+qyQGDQ2NqK+vh4nTpwAwGpLHQ5H1m+zlVIOUk5W2nTR0tISV/mZTqdDcXEx3G43XC4XXC4XvF4vOI6D1+uF1+uFzWaD3W5XbHdcVVUV9Ho9iouLU/r6qapIohMxMpRK1X+qhskEeDzKjmes8fv9OBiltKSwsBAlJSVZ91Y2XHt7O1pbW1FaWoqioiIcPnw4rjPfJJWVlQiFQmhpaYFKpZJnmtKs02KxwGAwpCTVkGmmTgUOHACmTAH270/e89IMOAM5ncDZZ/d/7vUC1dXKjSddjh49ivr6+rh2aSVqqD64UsevaARBQEdHB7766ivU19ejoaEhlUNMmM/ngyiK6O7uhsPhSCj4AqzVpdlshtlsjuiaFggEYLPZYDAY0NbWlvXvGGKxfTsLvsleixnzATgbNzPU1rLftuHWrFFmLOnU3d0tXxPpbxsLKYgOtUmgpaUF7e3tEARh0Ft5aTGrr68PAODxeDKyLaPBYADATjqWFqkSYTKZwPM8iouL5YU2iSAIMBgMOdOYZ9YsNvNN9lrMmA/AN9zAgtkNNyg9kn4NDcC3v80W2KLNbC+8EAiPDxwHPPZY+sanlPAdWseOHUtJEG5vb0dzc/OwudCWlhYcO3YM7e3taGxsxL59+1BfXw+v1zto11Umzv7MZjPy8vLi2nARjcPhQENDA44ePYpAIAC3W4XaWivcbhXcbjfa29sTagRE+o35ALxoEcunLlqk9Ej63XMP8NFHQDA4eGbrdAIbN7KPdTpg1y4gFMr+TQCxmDRpUsTnx44dS9p2VqkBTaz1oj09PYN65bpcLgSDQVgsFnAcJ789zzQej0eepSciLy8Per0eGo0GHo9HTj+8954ZDz1kx3vvmeX7kdEZ8wF4/Xrg2WfZNRV272ZlSrt3j3xfpxO4/37gvffY5yrV4Jnt6tXA888DggA8+mj/brhcwPP8oBnm4cOHYw7CXV1dqK+vx5EjR+D3+yNSCC0tLXKKI1bR1qd9Ph9UKhXsdjsqKioybvYnCELc3+dAfX19MJvN0Gq14Hle/h5nz3bjF79owezZbNafad97NqIqiATs3csC47FjbHYaDAIWCwuwDQ1sBtvaCrz1FmA0suA8Zw4LrMuWsftPmQL8858seIfTaNjXVSqgo2Pw13NBfX19xOdGoxETJ04c9jEDqxqkRSJpA4LH40lquqCwsBBlZWVJe75k6OnpQUNDw6hTDwDb5iv1chjKtGnTKAiPEm3ESMDq1ZHNcfR6YNs29vEDD7BAK+nuZs10mpvZTqp77mGB+amnBgfXnTtZ8AWA6dNzM/gCLOCGz+K6u7vh9/vR3d09ZDPw8NSCdHKvdD+z2YxgMDgoAHMcF3WWG4uOjg44nU7Y7Xb5NZQMRoIg4Pjx40kJvhqNBkVFRejp6YHf74/Y7CCRFujI6Iz5FEQqPP44MHkyoNWyGW1TU3+q4O672aKZxGgEHnwQmDEDsNlYA58PPojeVevmm/s/1utT+z1ksmgNX1paWoY8i6yrqwtOpxN6vR6lpaWYNGkSeJ6H0+lEMBiU62LDFRQUDNvGUPV1n9Hh+h0IgoDGxkbFz0iTUizxHLA5nLy8PDgcDjn1o9frUVBQIH/dbDajsrIyKa+V6ygAJ+DMM1llRV8fqwsMn6mOHw88+SRLJTz1FKvh/egj4Msv2dcffJClKqI591x2NZuBP/whtd9DJgv/YZdwHAe73Q6dTocTJ07A4XDIJWBNTU0QRVFeONu3bx8aGhrQ3NyM1tbWqAtvPT096O7uhsVigdFojPgaz/MIhUIA+vPAQ/XQtVgsKCkpQSgUUqwkzel0oqurK2nNcbq7u+F2u8FxHHQ6nfyLbdq0aaioqMjI3He2GjEFMVxR/Eh5uVy1cmV/1YLTyeqQw515Jmuw88IL/XWFDQ1ARQVw1VXAb37DAnmu4nk+Ig1hNBpRWloKrVaLxsZGeVusWq2GzWZDeXm5fCy7FARHOu9MEAQUFhaC4zhwHIdgMIi+vj5wHAdBEAalJ4ZaCAwGg/D5fPB4PFCpVGnpRSBtmS4uLoZWqx30y2I0qRWz2QyDwQBRFOV3AW1tbfLfdbb1Wsh0Iwbgu+66CydOnMApp5wS8Y/KcRyeD092kqhqa4HNm4Gf/AT4y1/YYt3XrQdw9dX9Hz/wAPDKK6ztZC4HX4nJZJIDcCAQwOHDh2GxWFBQUIBQKASdTieXgNlsNpjNZuzbty/m5/f7/ejq6pLftptMJrl0i+f5mGez0hjz8/PTUpIm5Xp7e3shCAKqqqrkQClJNPhK7zK0Wq3cvN1oNEKlUmVkud1YMGIArqmpwbXXXostW7agtLQ0HWPKKnV1LGhu3x65S8bpZCmIv/4VWLuWtTR8/XUWaH/5S3Yfh4Pdz2pluWOg/5rrpEDr8XjkTROdnZ1wuVyYMGEC9F8nyaXZYCLNuQOBQESwNZvN6OnpSSiXKj2mq6srpQtybrdb/vsQRREOhyOh042jEUURra2tKC8vj2hhSbPe1ImpDK2+vh6BQABnhzcoSINMLUMLF61Jx+7dwHXXhdDby3JyF17IybW/TicwYQLgcokARKxdC2zcqEJtLauSyNXKh6E0NjZGPcFh0qRJ0Ov18tejrdTHQnq7bjab4fF45NljXl5eXJsZOI5DQUEBnE4nSkpK5NuT2ahG2kbtcrmg1Wqh1+vR1taWlOcOV1FRAbPZDLfbrXh1x1gX0yLc9OnThwy+77zzTlIHlG2iNelYtgxy8C0pEfD44/1fs1qBCy6QPuPw3HMiamuBdetYuoJEKi4uRn5+PtTqyDdr0tlgxcXFsNlsUSsnYiGKohyERVGEyWSCWq2OeyeZKIpwuVyw2+0IhUJobm5Gc3MzGhoaYt5I4nK5sG/fPjQ1NUVNgbjdbjgcDvT19UGlUo1qt9tQpN19PM/TNuM0GHUVRK7ngaM16Qhv3u1wqDBjBnDfff23PfkkUFHBZlozZvhx6aUCHnkk+okLDQ3Az37GrvHYtUuAxRLCrl2Z1ywmHlqtFuPHj8fUqVNRWVkJjuOg1WrlTRBarRYVFRVxbYt1u1V49VUbXn3VBrdbBVEU4fF45FlveC2tSqVCUVFRTE3GpZI3j8cDjuOg0Wjg8/li3v4sBd7Ozk60tLREBGFBEBAKheRfNNI5bMmm0+ko6KbRqANwPAn/UCiEjRs3YtGiRVi8eHHGtvMbrfvvB77/fQ4AB1FUQRTZBgzJ+PHAhx+qcNVVfhQU+DB1qoiiIgEOhx8//akXX33VP2PauJFt8pD6Q8TC6QSuvZaD281hyRJlz+1KJovFgjPOOAOTJ0+Wc8CSeP4fvveeGVu32rF1K+trIJVv9fX1IRAIQKPRoKSkBGVlZZgyZYp8lE8sx5/39fXJ7SCNRiMMBgMKCgoGdVaLRjqvjed5uN3uiNpiKScrNQSKp7F6PFIxqyZDG/VOuHhqD9955x34/X68+uqr+OKLL/Cb3/wGv//970c7hIzzl78AH34ILF7MFuGcTmDcuMj7WCyAyaTBjh0FEEVg6dIQZs4MYM8eI7q6fHjzTS2cTraTTq1mGz9i4XQCv/gFEAiwf5chylezmrRCbzab4fV60dTUNKgSYDizZ7vR08PJHw8M3hMnThxU98vzPAwGAzxxdMaXzkbr7OxEXl4e2traEAqFos6m2WLueDz4oAOXXGJGd3e33O7SaDTKneGk2Xqy5eXlwWAwoLi4OOnPTYaW1o0Yn376KS74OgE6Y8aMQXv+x4qVK4HeXuBPf2LHmU+fHkJ3t4A33xTgdAK33AKUlADbt6swYYKIwsIQamqAjg42q5OuN90EvPYaa8wTZW9CVHffzWbMZ53FobSUw8svj729NtJs0O12y2/bA4EAVCpVTIHYbA5h0aIuLFrUBbM5NOjrQ226SHSjQ1dXFzweD0KhELq7u6POgpcvBw4cUOHOO0uh1+vR19cHt9uN1tZWNDc3w+VyyX1+k01KORQUFAz5vZPUGPUMOJ63fl6vN2KxhOd5BIPBQQss2crpZAtpDz/Muq9VV7NNF62tIjo7VViyJISHH+4/bh4Q0dDAYccOYO5cFcaNY30mHn+c/aDv2vX1vcT+44mGU13d31/46NH+U5XHGqkmVTq9Qgpo0oaE0VCr1fD7/RGBSJpxS8+fSMWFVC8s7TDTaDRyOqGoqAjbt/NyOSPAFhdDoRD0ej2MRiPa29sRCoVGtcliKFLz+aampkEtQUlqxTQ9OnjwoHxw4UA3xNHpPLy4HmA/MGMl+AJATQ1bMPvnP1na4JNPWFBevJgDx7FrZIwQcfbZbrm935lnslaVZ57JOq6F/5ytXTvy64f3Fh7rx9h3dnbK/YKTtQUXYAtp0jbnjo4OuelO+IGWo2l4w3EcXC4X2tvb0dvbC4fDAafTOWgxV6vVorKyEjabDT6fD36/P6JMLhUMBsOIeWqSXCNGv0cffRQff/wx/H4/rrvuOlx++eURX//e974X84vNnDkT//Vf/4W5c+fiiy++wORYE5tZ4ssvWX+IV14BAgE20/38c+Cll1Q47TTg5EkOy5eHP4LDZ5/lo7Jy8A/V6tWRnw+3yL93L7v/+vVs9v3YY2O7j7Db7Y445ywZQclkMkGr1cLlcsnPLwXckpIS2O12eYFqNK8npUjCg1wwGERHRweAwXXDUrol1bRaLbRarfxatPkiPUYMwB9//DFeeeUV+Hw+3HLLLYMCcDx+8IMf4MMPP8RVV10FURSxefPmhJ8rUzidrO5X2i8ycyb7fNUq9vlHH7E8sMHAejwIAusDMX8+8Kc/cfj1rznwfOTCEs/zuP129jjJihXRX7+uDrj4YkCKR0k6QCKjmc1mdHZ2ykFYrVajqKgIPp8v4a5kA3fFhQdIp9OJCRMmoLOzc9Rjl543PJXg9/vR0dEh918ID35msxmhUAhdXV0pq3wAgNLSUphMJtp2nGYjBmApF2YwGEbda1SlUmHTpk2jeo5MU1vbH3wBNuOVGvGsWcOa60j1veedxwLyxInAli39OV5g8Exn0yYeQD4ADlOnskY90rblcEuXsuCr0yFiw8dYxvM8Jk2ahJ6eHjQ3N6OkpAQnT55EMBgEz/PQ6/Vxnycn5UGj8fv9OHz4cFLemvM8H7HRQ6fToaioCADkxjqCIETMgkOhUEpTDwBbn7FYLDTzTbOxt0SeZvPmsdmsRHqDsHIlm41K+1RqaoDPPmMfHzrEekKEM5vN8gmzzz7rxj//yRYrtVrg5ElWB3z11YDdDuzZ0/+4hQvZ6Rnr1kXvMTyW6fV6nHLKKQgEAvLkQBAElJeXR21pOZxgMDhs0B4YfOMpewun1+sjFgtNJpM8c/f7/WhpacHhw4fhcrnQ2Ngo9zJOdX1uvH9fJDlG7AVxzjnn4LTTToMoijh06JD8McdxeOWVV1I6uER7QVRXs9nnYwJPQoUAACAASURBVI+l7zBLqQIiWj+H559ni3N9fWymOns28PTT0bueNTQAp50Wkut458/nsHcvMG0aqykGWBD+eifusK+bCwRBgNPpRFtbmxwkKyoq0NHRkdK37IkymUwRgT4/Px8mkwmtra0oKSlBR0dHRIWFVqtN2sGkw7FYLCgvL6ddcGk2YgCW+qwO1Nvbm/KSlUQDsFbLFsE0mszIiTqdbAb85ZfApk3Dt5u8+mrglVdE8LyIn/0M+OgjFb78kgVgngdaWlhAnzMnfePPRH6/HydPnpQ7gZWVlcFqtcp59JMnT6Zkw8JoqdXqiFSe2WxGRUWFPO6Ojo6oDXY4joNarU7aqRfRlJWVxbTlmiTPiDngioqKiM9PnDiBF198EbW1tfjoo49SNrDReOyx/hlwJrBaWYogFqyiisOVV3Korga+8Q12e2sr0NnJ+kzkevAFEHEAp0RqIAOwYCIIAnw+n7xjTip75Hl+yLf0qaizDQ+6A9dRPB4Pjh07Ji+0CYIQddYrvescOD6e5+WG8iT7xJzIev/997FixQpcfvnlsNls+Mtf/pLKcY2KlH9NV/ohXF0da1FZV5fY46dNY9c332R9gx99FLjwQuBb30reGMcarVYL64D8i1arxSmnnILp06ejqqoKEydOhMFgwPjx44fM38a6ky7a4xK9j3SUktRDoq+vD36/P+r9/X7/oF8OoigmJfiq1Wp0d3dHHPWUTHv3stTb3r1Jf+qsNuL/nJqaGlx22WX461//iqVLl2LGjBm48cYbI3qe5rrdu9ksd+VK1mrywAFWnZAIqWmPy8XOjztyhG3OkPoJZ3h7ZEVMmDBhxNylXq/HuHHj4HA4wHEcVCqVvAlI2siR6LluZWVlw75+MBiMe9NRLLv6OI5LWs5WFEW43W60tbWl5IDR1atZWeXA+vZcF1MA/ta3voUVK1bg/PPPT3j1N11GOwNNxIoVLGCG9xVKxkaIO+9ks99bbmG9JQB2qvLOnaN/7mw3ffp0+U+s/QsaGxvhdrvh8/nkpjgVFRXyZEKj0SS0M7OjoyOmQCilC2LduRetIVC4RJvQRyMIgnzAaCrqgB9/nP1fzpVSyViNGE3/8Y9/YPr06XjggQdw5ZVXoqWlJSMXNySsqQkG7Dgb2p49QFlZZGlXvLZtY93Nbr6ZVTksXw5s2JDYc33dkRB6PWtr+f77bEed9C4zFFImtTIWDKyKkDY9FBQUoKKiAqeeempCM+De3t4hKxUsFgvMZtbyMt6ddAOfc+DYkl0dUV5ejuLi4pRUQoRvsyf9RgzAWq0Wl112GZ5//nk89NBD+M53voMf//jHWJ2h7yWinVAxlJUrgblzWWXB0qVsZmkwxD/DXLiQVTpccw2rcLj++sRLwqqrWfCVmurMmiUgLy8EQAQQgk7X/zUSn/Lycnn2WVBQIOeNw09/KC8vH/LxsQYm6TU0Gg1KS0vlI36AxLcxu90q1NZa4Xan7h1oU1MTOjo6qBdEGsX1rzlhwgRs2LABb7/9NuZFO74hA0Q7oWIo4SmDmhoWkHt6RNx8c2K5wGuvZbPva64RcPDgwbh3YwFsU4XBwK5OJ3DrrQH4/RwAEevW9aCnB1iyJO6nJehv6D59+vQha15tNpt82sZAGo1mxHSHWq2W7xMMBuXmUwaDYVTrJu+9Z8ZDD7EG8qnicrnkNp8kPUZMeF0Xfr7OABdddFFSB5NuN9/MgvDNN7PSrupq4MYbRXBcAGq1BkuXAjt2xPZcTmd/mkCn88Pv96OpqSnuhkMXXsh21l14IdtgsWePFqIITJgQxF136eL8DkkirFYrAoEA2tvbI27v7e2VF76G+gUdDAblLdE6nQ4ulwsdHR3w+/0xnagxFKljnnRNBY1Gg6KiIuoFkUYjBmCDwYDjx49jzpw5uOiii+I6eyvThffPBdjMcudO4P332Qympia2ALxzJ9vpFgiwOt6rrmLnlg33dnYof/wj8OyzgNnMjq1fvRr46KMgnn6aR2Fh/4ytoYFtZ7777uE3dpD48TwPu90Oi8WC48ePRyx0iaIIQRBGrBcWBCGi9arBYIBGowHAcs/x9i42m0OYN88Z53cSn4qKioQPNyWJGTEF8fTTT+Pll19GUVERtm7dim3btqGlpQUTJ05Mx/jSbskSFVQqdp5bLKVkdXXADTew4AsA3/42sG6dDpMnT07oP/NLL7GZ9NatbMeb16vCP/+pwYwZkW+XH3iA5bmvuy6xvDUZmV6vx6mnnirPXMPLvoxG45A54WiVQsFgUF4ENBqNGTmRSeUuOxLdiFuRB2psbMSWLVvw6aef4oMPPkjVuAAkvhV5NKZOZXncKVNYLnk4TifbOCE1MVOpWN3uaGakBQVAVxf7mOeBw4eH7hnxwAPAc8+xTSdqNZsx52I/iFSTmuSE76YbP348fD6f3Lg9PCUx1Aw3/ASPTAt2hYWFKCkpoV4QaRbzItyRI0fwxBNP4JZbbhmTbSUlI1VRSHXGd9zhR1FRCC0tIgwGwGhkjdhHmw4In3XfcMPQzzd+PPCHPwDf/Cb7XBRZzpgkX3d3d8SRRKIoyme1hTcBkgyVXggEAujt7c244AuwMVPwTb8RZ8Dbt2/HW2+9hcLCQlx66aW46KKLBh0JnipKzICjcTqBJ59kaQGnnIYLAWDlRqWlnDwLdjpZ/a6Uy423b4PTCbz8spRLHnlG29DAWlVOnsxmz1dfTbPgZBMEAQcOHEjKmXMDDbegly46nQ5VVVV0IKcCRgzAU6dORVVVFWw226AdPJnajnI07ruPbQc++2wWQKUTLV59NfKMNoMhBJ+Pg0YjYv16FZ58kgW+8KPzwttGplJDAzsV4+BBtglk27bUv2auOXTokJzDVavVCIVCCQdkvV4PlUqFvr4+BINB6HQ6xVpnchyHqVOn0uxXISNWQTz44IPyx42NjdDr9bj44oszfktyou65hwXazz5jxwp9/HH/ApuE44AZM1Q4eBC4/noOTz4JeDzsj6S0lFVRJGLPHpaKqKmJbQb9wAPAwYPst8POnSK2bRub/zZKkU5JlkrMRtv8RqfTyUfUA1D0YNpx48ZR8FXQiD+pR44ckf/09fWhqakJt9xyC/7nf/4nHeNLu1//mgXYM88ESkoGB18AmDCBzYzb24Hf/Y5VIuTnA5WV7Ot33skW5hJtG7l0af/uvFjcfTfAdsqRZPN6vTh48GBEDjgRxcXFMJvN0Ol0sFgsEc8VfsBouqhUKkyePBkWiyUlz+9yubBv3z64XK6UPP9YMeKv3ttuu23QbX19fVi8eDGuuOKKlAxKSb/6Ffvz9NOspzDHsRkxzwM2G3D++cDf/95/f7MZuPRSliNOlHSq8eOPs8BfU9M/A47F+PHA9u1BrFqlxjXXhOB0qigPnASCIOBEWE5JWqiScrbd3Rr87W+s1HDOHBfM5ugBmuM4+P1+eL1eeQEvPOhGO6gz1UKhUEpzvk1NTRAEAU1NTSkL8mNBQu998vLy5KLysUoU2RFCEkFgHc/+67/YTPfIEXZ7Zyewdm3is12nkz22qYktoP3f/7HP480dL1umBc+HcNttKnznOyEsWUJpiNFwuVw4efLkoIAYvmD27rtGbN1qBwDo9eKQGyWkHWZ+vx89PT1RZ7w8zyMvL08+4SPVRrMrLxbl5eVoampKaDNSLkkoADscDkXeNqXThAlsUc3rZRsj1GpWlfDnP7MFupMnWe/f48cjS9b27gWuvBI4ehR45pmR+zbU1rLgC7DnGo3Zs93YsMGH2bMNAGgKnCiv1xsx8x3K7Nlu9PRw8sdDsVgsOHLkSNTZrVQzPNypzMmm0+kwbty4lL6GxWKhmW8MRqyCWLduXUT1Q19fH/bt24c777wz5b0gklkFIVU3/PrXbHYp9YAYqrNYVRWraBg3ji1ySb2HamtZn4b3349+EObs2exrwNAbKcIX2c4/n5188cILLJCPpo+wIAjy2WK0sJK4/fv3J+WUiVhSCqk4dFOj0UAQhEE5a5PJBI1Gg+LiYio5yxAjBuD//d//jfhcp9PhlFNOScue8WQG4MgKOqmGV8TSpaqo/R6kAFxZ2T8zjaU6QZoBf/UV691rsQB/+1tkd7aysv7dc7t2RQ+6bW1+7NjRjfz8fFx7rTrmnG5dHStF2749to5wJJLD4UBra2tCjw0PuDzPIxQKDRmApXPiDAZD2tIOer0+5QfpkvjEvRU5nZIVgO+7j21WkBgMQfh80gyRQ1fX4JlstEBmt7PDMUtL+wPoUBoagLPOYnnjgdua9+xhfYgBFqCdUVKH11/vwvPPmwGIWLVKFfMin90eQmsrB51OxP79KmrUEyPp3cNQp4AbjUYEAgF5tjpwu7F00oV0m8VigV6vh8/nG9TeMS8vb8hDQVOF4ziccsopadtERWKTEys10jlrEpst8tuOtoU3Wl9hqegjluKP8ePZzDfatuY5c9jM12IZetPEn/4kvcPg8NxzI7+epKODXXt7OTzwQOyPy2VStcPA4MtxnHzs0cSJE1FZWSkvPhcVFcFgMMj3FUUxIiBLfSL0en3E/YDBJyOng91up+CbgXIiAEu1vePGsdnwkiUq8DyHGTM4PPxwf353oL17gdNPZ30eLrqIpQ5MJmD69NheN1oQr6sDJk4ENm0KYdWqbnzve5ELL3V1bFux1dp/+7nnxv69PvVUH7RaEbNmCV/XB5ORHDt2LGrz/IEr+J2dnXIfB57nYbFYwHEczGZzRE6V4zgEAgE5nTEwxZDOrccqlQplZWWDTo0mmSEnUhAAe5tfW9sfbF95hZWaDdc7IXxBDWAz1osuYj0hEnlrX1cHfO970uYOEYAIngd+9zsRq1axlAjrxsb+SVQq4D/+Q8SuXZRKSBWv14tjx44Nur24uBilpaURt/n9fjQ3N8v1vHl5efD7/bDb7RAEAW1tbQBYcP73v3n89rfluP32JkyZktxFNkksi3wTJkygHr8ZLCdmwHfdxTZRrFjBgrDVynro/upXg9MPe/eywLt3L9sYMW1a/9dcLuC11yKDcjyWL+9v2q7RsB8cQeDw859zOHKEzYq2bwdUKvY1vV7Aq6+6KfimiCAIaGhoGHS70WhEUVHRoNu1Wi0EQZCDXl9fH6xWK6xWq3zisfS8v/1tOf71LyN++9vU1cHGMnei4JvZciIAS+0s/P7+GfC8ecCiRazfw6RJbLZ53nnAjTeyALt6NduV9u9/AwPbHo90HJ7UsrKuLvJ2qdVlZSUQCHAwGqX2hhzuvjuI559n6Y0XX3SjqCiAp55yoLIytQXzuaypqUkOYnl5eZg2bZqc7x2qjC+8/t1sNsNut4PneVitVjnXq9VqcccdzfjGN7px++1Nqf9GhqF0pzUyvJwIwHfe2X+V0g1WK/Dii2yjxZEjLB3xv/8LFBWxOt/HH+9//KxZ/XnfadPYrDla5YJk+XLW1H358sjbpZzwiy8Cp53G4aab1Ni0ScRVV/Xi9NP9WLdORG0tsHBhPg4e7Ma111KD7FQKr04YP358TH/X0snKFRUVqKqqAgB0dXVFHEHk9/tx+ukCdu48nrL0Q6zogM3MlhMBePNmFmA3b468fds21kQn3He/C7z3Hpv9hrvtNkCnY4F75UrWs3coIzV1nzUL+MY3gti6NYT9+0N48kkfvv/9E7j77k5ceqkQcUw6SZ3wYBrrxgSbzYYzzjgDNpsNAAtwLS0tcDgcEfcLBoMp6R88Eq1WK6dCTCYTHbCZ4XJmEW44e/awLcOLF7NdadEW5aQa4HBbtgDr1yf2mhpNCMEgB7VaxIEDTtx6awhvvFEAgyGEXbs4zJ2b2uBLGzaSQ6ofNhqN6OrqGhSIw0m1wdKPnNfrjTi4czhqtToi/zwUqeKBdkRmh5yYAY9kzhwWXB9+OHrwdTqBU05hH4dPlO64I/HXfOSRIDQaEY88EsR//7cVf/tbAUSRQ3c3j+uuY/cZKpccD4fDgfr6ejQ0NETkA4dKk5D4SO9WADbrrZR6kg6g0WhQWloKnufR3t4OtVo94uw0vGFOMBgcMfiazWZ5QZDeQWUHCsBD2L2bpSemTmX9fj/+mN0+ZQqrBQZi25AxlJ//XAu/X4Wf/1yLyy9Xoaio/+3qjBmsUD8ZQVLaVuvxeOQyKYDVQ1ss7EpGz+FwoKurCx3STpgBAoEAXC6XvHBnNBoHnYJhMpkiNkvEs0WZ53lUVFRQ0M0yORWAnU521PtwC2iSFSvYAt2BA8Bf/8qqJE47jZ31duIEO4346aeTMy6rFXj7bQ5nnRXAWWcF8PDDrEndSLnkWJSWlqKxUY1f/7oce/e60Px1n8u33wbcbnYlo1dcXAyLxTLs6Ra9vb3geR5msxmNjY3oko6//ppOp4PVapWfayQcx8llZoWFhRR8s5ByZ6GkmdQPIi+PfS69zR/Ktm2s8Y7JxAL2okXAY4/1pyhGeny8ZszgsW4dj5tuEvEf/yHid78TsGoVH9FDIl6CIECtVqO6uhK1tQZ0d3N46KFGlJSU4O672Q8r7ZZLDq1Wi7y8vIh3GRKdTgeVSgWbzYaOjg74fL6ouV+/34+Ojg6o1WoEAgG5v8RQqQdRFFFeXo7u7m5abMtSOTMDlvpB9PWNXMcLsA5lHg+wbx/7+KWX2J9w0rbis89mGzdGa948wO8XIQgc1qzhsHChFw89FIxpxh6NtEIfCgmDbh8/HnjoIVbz7HSyyg6OC2HZMhfVjibIOcQ/FM/z8Pl8aG9vR0tLi7xop1KpoNfrkZ+fL++6E0VR3u4siiJEUYTRaBzyNbu7uynfm8VyJgBL/SA2bYrv2HarlZWcBQLAz3/O+ghLP2fLlwPHjgFffME2boyW1cq2JWs0Is46y4c//cmI22/nceWV8TVvEQQBXV1dMBqNsNvt2LJFgyuu6MKtt7ZCpVLJK/aPPurH0qUh/O53Qfz+9wDAoaYmn2pHEzRUX18p19vX1we73Q673Y6qqiqcfvrpmDRpktwcfaiytaEqJXQ6Hc18sxyVocXgvPPYJg3JrFlsd1xdHStds1pZTnhg7fBofPWVH5MnqyH1LX7rLR8uvjj6tlKnE7j33iBqaoBgUIWnnvLgm99sgt1ul1fo/X4/HA4HiouL0d3djZaWFlx55QTU1+uQny+gp0eFYJBDaWkQjY0qmlEloL6+PurteXl5crog2tbgjo4OOTcfjdQ7eCCbzYaKiorEB0wUlzMz4NG48srI8jOpLGzWLHb00OefJzf4AsBpp2lx+unS70YOl1xiwIsvRj8GqrYW+N3vVPB4ePT0cFi6NB+7d5dHzI60Wi3sdju6u7vlmfGkSay1osfDIxjkYDQK+NOffBR8EzDcqRbjxo3D5MmTY+rLwEWeHAAAUf898vLyUFxcHN8gScahAByDZcvYopy0gKfTped133yTx3e/6wEgQhQ53HijJupZfPPmARdfLAVrEQCHTZsit/j5/X4cPXoUTU1Ncq7ykUc4nHNOEBwnguOANWv8OP98at6SiIEbMIxGIywWCyZPnjxsH14p315QUACNRoPy8vJB9w9v9CPRarV0rNAYQAE4BlYroNezM97y8/u7pT3/PNtFN9rNEkMZPx544w0NfvpTFwDgssu6cPLkyUH3y88X8MwzHtjtLPgCItasaYrI5TY3N6O3txeiKKKzsxNNTU3Iy2vBm2+K2LKlB48/LmD5cmX7FmSz4uJiuRmPxWJBVVUVKisrRwySbrcbbW1t0Ov1OPXUU+H1egf9ku3p6RlUCZHBmUMSB8oBxygvj3VTkxQWsjPf8vLY8UQDjx1KJqcTePrpJnznO06YzSGUlpaioKBAfmva0dGB1tZWHDtWgXXr8vHIIx6cd15Q3hUlCAIOHTokr64DbAEnEAjAbrcjFDLjj3904dxzW2G19s/KqJds6km5+YKCAnR2dg6qDR6K2WyWmwGR7EUz4BiFxS4A7OifK65gB3SOdrPESKxW4JZbzLBY2O/K1tbWQSVPoijivPOC2L9fhblzLRGF+W63G4FAABqNRr5NEAQUFhYiFArh1Vd9uOceM95/3xJRghbL0exkdLq7u+FysQ0ysQZfgB0xRLJf2jdivP322/j73/+OrVu3pvulR+Whh4Dbb2cbM9xuYP58dpvVOvQJyclkMplw2mmn4fjx4+jt7UVnZycEQYBKpYIgCDCbzRG9A8JJi3Fmsxk9PT1oaGhAIBCA0+lEMBjEJZfY4fV6MWtWZFBXoptXrjGbzXC73fB4PIO+Ju2Gc7lcg75GC6VjQ1pnwPfffz+2bt2alT/Y69cDgsBOxRBFdjJGIsds7dnDzpbbsyf+x2q1Wui+XgHs6+tDW1ub3ArR5XINWS8a3pzF5XJBFEVwHAe/34+8vDyMG2fC3LkdMJsj/12GCugkuQb2hJCYTCaUlpZGrfWlWu2xIa0BeObMmbj33nvT+ZIZZ+lSljO++urInhT33cf6TYzUHCfaTEnS2Ng4qOtZOEEQoNVqI1oi9vb2DrmDKxt/UWYTQRBw5MiRiNy8RKPRoKmpCQ6HI2q/YtqAMTakJADv3r0bP/rRjyL+7N27F3Pnzo1a55hLampYGsPlYs19pOqJjRtZHnfjxhA++GDorcADT+odyOPxoLW1VT6lIVxXVxfa2tqQn5+PsrIy2O12FBcXR+1fAPQfrU5Sw+12o6+vL+K2kpIS2Gw2+Uh7t9sNp9MZUWfM8zylIMaIlOSAFy5ciIULF6biqbPenDnAWWcBH34ItLezPhPSmXUMhyuuCOHf/xZQWDj4h8xkMqGsrAwtLS1DliJ1dnaC4zh4vV6UlpbKzVqkcqa+vj5UVlZCEAQcPnx4yLGGQiG0tLTI556R5DKbzWhtbY3Y5VZYWAgAMBgMMBqN6O7uHrQLTroPyX5UBaGA6moWhIuKAJ8PuPlmgG2gYFeXi8OuXdHzgm63G83NzSPWgYqiCLfbDYfDgebmZrS0tMBms8FgMMBsNuP48eM4cODAsDu4jEYj3G435RtTRBCEiOA6YcIEeXZrs9mg1Wphs9mgUkX+mEZLWZDsRAFYAWeeyRr4fPUV8MQTwLXXhn+Vg0YjYsECzaDHOZ3Af/6nBT09bEueSqVCnrQ972s2mw0WiwXFxcVyisFiscDtdsPlcqG3txdNTWyTxkg5Xp/PB6PROGw3LpK4pqbIE5OH2jFntVoj+gzHU65GMlvaA/B5552HRx99NN0vG5N4GrYng9XK+gpv2QIsWyZCrRZhNAZx770n8fLLXnR0ROZft28P4cYbgb/9rQQAW6gJBALyDEmj0aC4uBiVlZUoLS1FYWGh3APCbrejoKAAHMfFnNeVZtHDLfyRxAiCAK/XG3HbUO80eJ6POLWZUhBjB82Aw6xeDVx/feKtJRMtMbNage3bVejtFdHQ4MZHHxVgzRob5s6N7AX8ySd98Ps57N3LakT9fj90Op08kw0EAlGDpXQKQ3t7e0KLagMXisjoRZvFDlfZoNfrMW3aNEyfPh1lZWWpHFrCRlNimatoK3IYrZbteNNoIrcdx6qsjJWY2e3AMN0FRySdmAwAzz3HobVVwO23czjttD7k5YVwzz2NOPtsNTQaDTQaDfx+P0RRhMfjQVlZ2aAZkiAIaGlpgdPpTLiHQGlpKXXfSqITJ05EbLAYC9u+k/X/P5fQDDjMY4+x4PvYY4k9vqaG/eerqRntOFg64lvfEnHhhcCdd3IQRQ4HD+qwf78eBw4Y4PP54HK50NHRAY/HA5VKJR9JLjVkl2a7TqcTTqdzUL44HtLhniQ5SktLYbPZMHnyZEyfPj3rgy+QvP//uYRmwBlq/XrgkUeAdeuA0lI2Az799B7MmePCT37ilHet6XQ6ubRMmv12dHTI5WMGg2HYUrN4TJs2jcrRCEkiCsAZqrQUaGtj7S+PH2ctJ1taWgblDsMPbdRqtdBoNOjr65P7Q0SrI018TKXo6emB2+2OmuoghMSHUhAZaudOwGJhfSdefhl48UUeOp190BE04b8//X6/HHBFUYTL5Upa8AUgB18Awx6hQwiJTU4E4GxcnZ0zhx34+dRT7DDRdeuAN95gBfom0zjU1lrhdqf3n0+v18sr9Zm6Ek9INsmJACw1wFm6NL2vu3s3KzHbvTuxx1utwIUXAm+8wT4+5RR2+3vvmfHww+WoqytI3mBHwPM8CgoKUFVVhenTp1P6gZAkyIkArNTq7IoVrOnOihXxP3bPHjbmH/0I+NvfgMOHgV/+kn3tggu6sH59E2bN6kzugAdQqVTgOE4+24wW4AhJrrQ3ZFfCnDnK1CVu28aC77Zt8T926VKgtZX9OeccVh73+OPsaxpNN+bNS01/Bp1OB41GA47jUFxcjN7eXpjNZgq+hKRATgRgpSxcyP4koqYGuOEG4Kc/BX71q8jm7waDIekNcoxGI8xms3yOnGS4E30JIaNDAThDzZnD8tbRmM1mtAz1xTDhJWoDSa0O1Wo1CgsLIw75JISkBwXgLDRScxydTiefmOtwOGAymdDe3g6TyYSioiL5pGS3203pBUIURAF4jCkuLpaDLAC5blg64FEi9ZwlhCgnJ6ogxhqrldUAR6sFDgaDNKMlJEtQAM5S771nxkMP2fHee/0tDKV+wJlstLXRhIwlFICzkNPpxJQpPkye3IspU3wA2BHyEydOHHR6bqYZTW10LI4fP476+nocP348NS9ASBJRAE5AdTXrHVxdrczr9/b24pVXivDJJ0a88koRKioqMH78+IwPvgCribZYEquNjoVUnkfn2JFsQN3QEjDaxu2jVV9fj8ZGNbZvL8GaNT58+9vj0j+IDHX8+HG5ukOqBCEkU9EMOAGjbdw+WlLwXb68DVOn0kaJcFKvCgq+JBtQGVoCVq5kf5Tg9/uxfXsJXnuNlZBddJFlhEcQQjIVBeAsIggCDh8+jOXL2Xlxy5e3gefT1xGNEJJcFICzyLFjxyAIAioqgHvuLhpJeAAADARJREFUaaJ6X0KyHOWAs0hPT0/E55WVlQqNhBCSDBSAs1g2naT71FMCtNoQnnpKUHoohGQMCsBZavr06UoPIS5r13IIBDisXcspPRRCMgYF4Cwybdo0VFRUYNq0aUoPJW6PPipCoxHx6KMZW3ZOSNrRIlwWyeYOZqtW8Vi1SulREJJZaAZMCCEKoQAcRV0dMHUquxJCSKpQAI5i+XLgwAF2JYSQVKEAHMX27cCUKexKCCGpQotwUcyaBezfr/QoCCFjHc2ACSFEIRSASVo5ncDzz7MrIbmOArBC6uqA004DfvnLsReMdu4EDAZ2Dffww0BBATuO6JVXlBgZIZmFArBCli8HDh0CHnwQqK1VejQjW7cO4Dh2HcnKlUBPD3DDDcDll7PHnXsusGEDIIrsFJGVK4Hycir1I7mNjiRSSF0dC1CLFgHr17OTgjMZF9bCYaT/MTt3su8tFlOm0IInyV00A1bIrFnAV18B99+f+cEXANaujbwOZ8kSYNcudvjmj3/MbvvGN4CiIvYLR6djt+n1VOpHchvNgEnamc2AxwPk5wN0eDHJZTQDJmm3YwebHe/YofRICFEWbcQgabdwIftDSK6jGTAhhCiEAjAhhCiEAnAS7NkDlJWxKyGExCptOWCPx4MNGzbA6/UiEAjgjjvuwNlnn52ul0+ppUuBlhZ2bW5WejSEkGyRthnws88+i29+85v44x//iAcffBCbNm1K10unXE0NYLezKyGExCptM+AlS5ZAq9UCAARBQF5eXrpeOuXmzMmNmW9dHdtCvX0720hCCBmdlATg3bt347nnnou4bfPmzTjzzDPhcDiwYcMG3HXXXal4aZJC4SeF0PZhQkYvJQF44cKFWBil0PPAgQNYt24dfvGLX+Dcc89NxUsrZvdu1uVr27axW+O6fXv/DJgQMnppywEfOnQIt956K7Zu3YoLL7wwXS+bNitWAC4Xu45V0kkh2Zh+oINWSSZKWwDeunUr/H4/HnjgASxevBg333xzul46LbZtY9trt21TeiQkGjpolWQiasZD4rZzJ+vnW13NOp9lA1pAJJmINmKQuEkN11euTP5zp2pTSzanT8jYRQGYxK26mvXyra5O/nOHb2ohZKyjAEwAAHv3ArNns+tIliwBfL7UpB9oUwvJJdSOkgBg6YQPP2RXJSsFcmVTCyEAzYDJ1+bMAdRqdiWEpAcFYAIAWLUKuOcedlz8xIlUL0tIOlAAJgDYwaB//ztQXw8cO5baetmdOwGDgV0JyWUUgAkAYMYMlgMGgMLC1G43TmUZGyHZhAIwAQB8+WX/x4cOpbZeNpVlbIRkEwrABABw1ln9V6s1ta+VyjI2QrIJlaERAMAXXyg9AkJyD82ACSFEIRSACRkCtbAkqUYBmJAhUAtLkmoUgAkZwvbtwJQpdAIISR1ahCNkCFILS0JShWbAJGG7d7OStd27lR4JIdmJAjBJWC6cg5csqWo0T7IbBeAsIAgCurq6IAiC0kOJQOfgxY4azZNoKABngX379qGxsRH79u3D0aNHlR6ObOFCwOlkVzI8ajRPoqEAnGW6u7uVHkJWUyoVIDWap37LJBwF4Cyj1WqVHkJWo1QAySRUhpYFpk+fDkEQ4Ha7YTablR5OVqupYcGXUgEkE1AAzhI8z8Nmsyk9jKxHZ86RTEIpCEJiEE/umOqjSaw4URRFpQcxlPnz5+P1119XehiEoKyM5Y7t9pFn0FYrq4+2WFiVCCFDoRkwITGIp4yM6qNJrGgGTAghCqEZMCGEKIQCMCGEKIQCMMkZH3wgYPLkID74ILN6apDcRQGY5Ixly0R89RWPZcsydtmD5BgKwCRn7NjB4bTTBOzYwSk9FEIA0E44kkMuuIDHwYNKj4KQfjQDJoQQhVAAJiQBtN2YJAMFYEISQMcxkWSgAExIAmi7MUkGWoQjJAELF9JRTGT0aAZMCCEKoQBMCCEKoQBMCCEKoQBMCCEKoQBMCCEKSVsVhM/nw2233QaXywW9Xo8tW7agoKAgXS9PCCEZJ20z4F27duGMM87ASy+9hEsvvRTV1dXpemlCCMlIaZsBL1myBILA+rA2NTWhqKgoXS9NCCEZKSUBePfu3Xjuuecibtu8eTPOPPNMXHfddTh48CCeffbZVLw0IYRkDUUO5Tx8+DBuvPFGvPPOO8Pejw7lJISMZWnLAT/zzDP4y1/+AgAwGAzgeT5dL00IIRkpbTngBQsW4Pbbb8drr70GQRCwefPmdL00IYRkJEVSELE677zzUFFRofQwCCFkVGw2G3bs2DHo9owOwIQQMpbRTjhCCFEIBWBCCFEIBWBCCFEIBWBCCFEIBWBCCFEIBWBCCFEIBeAU8Xg8uOmmm3Dttddi0aJF+Pzzz5UeUkq8/fbbuO2225QeRlKEQiFs3LgRixYtwuLFi9HQ0KD0kJLuyy+/xOLFi5UeRtIFAgFs2LAB11xzDa644gq8++67Sg8pJnQqcoo8++yz+OY3v4klS5bgyJEjuO222/DnP/9Z6WEl1f3334+6ujpMmzZN6aEkxTvvvAO/349XX30VX3zxBX7zm9/g97//vdLDSppt27ahtrYWer1e6aEkXW1tLaxWK7Zs2YKuri785Cc/wfe//32lhzUimgGnyJIlS3DVVVcBAARBQF5ensIjSr6ZM2fi3nvvVXoYSfPpp5/iggsuAADMmDED9fX1Co8ouaqqqvDEE08oPYyUuOSSS3DrrbfKn2dLrxmaASfBcO03HQ4HNmzYgLvuukuh0Y3eUN/f3Llz8fHHHys0quTzer0wmUzy5zzPIxgMQq0eGz8mP/zhD3Hy5Emlh5ESRqMRAPs3XL16NdasWaPwiGIzNv5nKWzhwoVYuHDhoNsPHDiAdevW4Re/+AXOPfdcBUaWHEN9f2ONyWRCd3e3/HkoFBozwTcXNDc3Y9WqVbjmmmtw2WWXKT2cmFAKIkUOHTqEW2+9FVu3bsWFF16o9HBIDGbOnIn//u//BgB88cUXmDx5ssIjIrFqb2/H0qVLsWHDBlxxxRVKDydm9Os9RbZu3Qq/348HHngAAJtdjaUFnbHoBz/4AT788ENcddVVEEWRWqZmkaeffhputxvV1dXyeZPbtm2DTqdTeGTDo25ohBCiEEpBEEKIQigAE0KIQigAE0KIQigAE0KIQigAE0KIQigAk6zz8ccfY+3atRG3Pfzww3j99dcxZcoU/OEPf4j42k033RTRgKavrw/f/va3sX37dvm2kydPYubMmVi8eDEWL16MRYsW4ZFHHhl2HP/4xz+wYMECLFq0CLt27UrCd0ZyDQVgMqZUVVXhrbfekj93Op2Dupq99dZbmDt3Lv785z8jFArJt5966ql44YUX8MILL+Dll1/Gxx9/jP3790d9nUAggAcffBA1NTV44YUX8Oqrr8LhcKTmmyJjFgVgMqbYbDYUFhbi8OHDAIA333wTl1xyScR9du/ejQULFmDq1Kl4//33oz5Pb28v/H7/kJ3DDh8+jKqqKlgsFmi1Wpxzzjn45JNPkvvNkDGPAjAZM5qamgAAl156Kd544w0AwLvvvouLLrpIvs+xY8fQ09ODqVOnYsGCBXjxxRflrx06dEhOQaxcuRLXXXcdxo8fH/W1vF4v8vPz5c+NRiO8Xm8qvi0yhtFWZJJ1dDod/H5/xG0+nw8WiwUAcNFFF+GnP/0p5s+fj+Li4ojtqLt370ZPTw+WLVsGAPjss8/Q0NAAnuflFEQsBjbu6e7ujgjIhMSCZsAk60yaNAn79u1DW1sbALao9q9//QsXX3wxADYbnThxIrZs2YIf/ehH8uOCwSDefPNNvPjii9ixYwd27NiBn/3sZ3jppZcSGkNDQwOcTif8fj8++eQTnH322cn5BknOoBkwyTomkwl33HEHbrzxRuh0OgQCASxevDiiCfdll12GjRs34pFHHsGxY8cAsKqFM844A1arVb7f/Pnz8eMf/zjudpsajQZ33HEHli1bBlEUsWDBApSWlibl+yO5g5rxEEKIQmgGTMgw3v3/7dkxDQAwCEXBmsMG2jBSbxXQvT9p7kYmphcS9l4zc827e1XV+4X4igsYIMQTDiBEgAFCBBggRIABQgQYIOQADZOfn9qc0r0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style('white')\n",
    "sns.lmplot( x=\"UMAP_0\", y=\"UMAP_1\",\n",
    "  data=result, \n",
    "  fit_reg=False, \n",
    "  legend=False,\n",
    "  hue='Cluster', # color by cluster\n",
    "  scatter_kws={\"s\": 1},  palette=current_palette, height=5, aspect=1) # specify the point size\n",
    "plt.tight_layout()\n",
    "plt.savefig('cluster11_100_SMOTE.png',dpi=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE bl1 oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from imblearn.over_sampling import SMOTE \n",
    "smbl1 = SMOTE(random_state=62, k_neighbors=10,  kind='borderline1',ratio=1)\n",
    "SMOTE_feat_bl1, SMOTE_labels_bl1 = smbl1.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 30.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat_bl1, SMOTE_labels_bl1, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_100_SMOTE_bl1.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 51.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat_bl1, SMOTE_labels_bl1, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_100_SMOTE_bl1.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE bl2 oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "smbl2 = SMOTE(random_state=62, k_neighbors=10,  kind='borderline2',ratio=1)\n",
    "SMOTE_feat_bl2, SMOTE_labels_bl2 = smbl1.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 29.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat_bl2, SMOTE_labels_bl2, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_100_SMOTE_bl2.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 55.3 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat_bl2, SMOTE_labels_bl2, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_100_SMOTE_bl2.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SMOTE SVM oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n",
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "smsvm = SMOTE(random_state=62, k_neighbors=10,  kind='svm',ratio=1)\n",
    "SMOTE_feat_svm, SMOTE_labels_svm = smsvm.fit_resample(features,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 30.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(SMOTE_feat_svm, SMOTE_labels_svm, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_100_SMOTE_svm.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 55.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(SMOTE_feat_svm, SMOTE_labels_svm, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_100_SMOTE_svm2.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ADASYN oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\deprecation.py:86: FutureWarning: Function safe_indexing is deprecated; safe_indexing is deprecated in version 0.22 and will be removed in version 0.24.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from imblearn.over_sampling import ADASYN\n",
    "ad = ADASYN(random_state=62,n_neighbors=10,  ratio=1)\n",
    "ADASYN_feat, ADASYN_labels = ad.fit_resample(features, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 33.3 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_1=knn(ADASYN_feat, ADASYN_labels, features_val1)   \n",
    "\n",
    "predicted_minority_val1=np.asarray(dataval_1.index.to_list())[np.where(predicted_labels_val_1==1)]\n",
    "\n",
    "with open('predict_val1_100_ADASYN.txt', 'w') as f:\n",
    "    for item in predicted_minority_val1:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1min 5s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "predicted_labels_val_2=knn(ADASYN_feat, ADASYN_labels, features_val2)  \n",
    "\n",
    "predicted_minority_val2=np.asarray(dataval_2.index.to_list())[np.where(predicted_labels_val_2==1)]\n",
    "\n",
    "with open('predict_val2_100_ADASYN.txt', 'w') as f:\n",
    "    for item in predicted_minority_val2:\n",
    "        f.write(\"%s\\n\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
